<?php

require_once(BaseConfig::LoadClass('doc_pdf.class.php'));

class ReportePDF extends PDFDoc {
  /**
   * Arreglo que contiene el ancho maximo de las columnas.
   * Este ancho NO contiene padding, por lo que es el minimo que se necesita para
   * cada columna.
   * 
   * @var array
   */
  var $arrAnchoDatos   ;
  
  /**
   * Arreglo que contiene la pagina en la que se escribira cada dato
   * 
   * @var array
   */
  var $arrPaginaDatos  ;
  
  /**
   * Arreglo que contiene el offset X de los datos
   * 
   * @var array
   */
  var $arrOffsetXDatos ;
  
  /**
   * Arreglo con la informacion para el conjunto de titulos (Esto es, las columnas
   * que se indican como conjuntos en $arrDifHeader)
   * 
   * @var array
   */
  var $arrConjTitulos  ;
  
  /**
   * Indica si las paginas se llenaran a todo su ancho con las columnas
   * @var int
   */
  var $intLlenarWidth  ;
  
  /**
   * Padding a la izquierda de la pagina
   * @var int
   */
  var $intPaddingLeft  ;
  /**
   * Padding a la derecha de la pagina
   * @var int
   */
  var $intPaddingRight ;
  /**
   * Padding hacia arriba de la pagina
   * @var int
   */
  var $intPaddingTop   ;
  /**
   * Padding hacia abajo de la pagina
   * @var int
   */
  var $intPaddingBottom;
  
  // Alto y ancho del area escribible
  /**
   * Total del ancho usable de la pagina (Menos los paddings)
   * @var int
   */
  var $intTotalWidth   ;
  /**
   * Total del alto usable de la pagina (Menos los paddings)
   * @var int
   */
  var $intTotalHeight  ;
  
  /**
   * Tamaño de las letras en BOLD
   * @var int
   */
  var $intBoldHeight   ;
  
  /**
   * Tamaño de las letras normales
   * @var int
   */
  var $intNormalHeight ;
  
  /**
   * Pagina actualmente siendo procesada
   * @var int
   */
  var $__intPaginaAct  ;
  
  /**
   * Total de paginas que se necesitan para los datos. Esto es, si los anchos
   * de los datos requieren que se hagan dos paginas para acomodarlos todos,
   * esta variable contendra un 2.
   * 
   * La multiplicacion de esta variable y la de __intPaginaAct nos da el total
   * de paginas actualmente procesadas
   * 
   * @var int
   */
  var $__intTotPags    ;
  
  /**
   * Arreglo con el color para los titulos
   * (En formato array(R, G, B))
   * @var array
   */
  var $arrColoresTitulos   ;
  /**
   * Arreglo con el color para los subtitulos
   * (En formato array(R, G, B))
   * @var array
   */
  var $arrColoresSubTitulos;
  /**
   * Arreglo con el color para las primeras columnas alternas
   * (En formato array(R, G, B))
   * @var array
   */
  var $arrColoresAlt0      ;
  /**
   * Arreglo con el color para las segundas columnas alternas
   * (En formato array(R, G, B))
   * @var array
   */
  var $arrColoresAlt1      ;
  
  /**
   * @var Reporte
   */
  var $oReporte        ;
  
  /**
   * @var array
   */
  var $arrDatos        ;
  
  function ReportePDF($oReporte, $arrDatos, $strOrientacion = "P", $strPageFormat = "A4") {
    parent::PDFDoc($strOrientacion, $strPageFormat);
    
    $this->oReporte = $oReporte;
    $this->arrDatos = $arrDatos;
    
    $this->__intBordesPrueba =  0;
    $this->intLlenarWidth    =  1;
    
    $this->intPaddingLeft    = 20;
    $this->intPaddingRight   = 20;
    $this->intPaddingTop     = 20;
    $this->intPaddingBottom  = 20;
    
    $this->__intPaginaAct    =  0;
    $this->__intTotPags      =  0;
    
    $this->arrColoresTitulos    = array(130, 130, 130);
    $this->arrColoresSubTitulos = array(150, 150, 150);
    $this->arrColoresAlt0       = array(200, 200, 200);
    $this->arrColoresAlt1       = array(250, 250, 250);
  }
  
  function SetFillColorByArray($arrColor) {
    $this->oTCPDF->SetFillColor($arrColor[0], $arrColor[1], $arrColor[2]);
  }
  
  function __AgregarPagina_AUX() {
    $this->oTCPDF->AddPage();
    
    if($this->__intBordesPrueba) {
      $this->oTCPDF->Rect($this->intPaddingLeft, $this->intPaddingTop, $this->intTotalWidth, $this->intTotalHeight);
    }
    
    $this->SetFillColorByArray($this->arrColoresTitulos);
    $this->oTCPDF->SetFont($this->__strUltimaFuenteUsada, "B", $this->__intUltimoTamanioUsado);
    $this->PonerTexto($this->intPaddingLeft, $this->intPaddingTop, $this->intTotalWidth, $this->intBoldHeight, $this->oReporte->strNombreReporte, "C");
  }
  
  function CreateNewPage() {
    static $__intContador = 0;
    // Obtener las columnas el el arreglo especial
    if(is_array($this->oReporte->arrDifHeader) and count($this->oReporte->arrDifHeader)) {
      $arrDifHeader = $this->oReporte->arrDifHeader;
    } else {
      foreach($this->oReporte->arrInfoReporte as $strNombreCol => $arrInfoCol) {
        $arrDifHeader[] = array(0 => $strNombreCol);
      }
    }
    
    $intPagAct     = 0;
    $this->__intPaginaAct = ($this->__intTotPags * $__intContador++);
    
    // Se crean tantas nuevas paginas como se necesiten
    for($i = 0; $i < $this->__intTotPags; $i++) {
      $this->__AgregarPagina_AUX();
    }
    
    // Header distinto
    foreach($arrDifHeader as $arrInfoSeccion) {
      if(count($arrInfoSeccion) == 1) {
        // Solo se imprime una columna
        // De todos modos se imprime entre dos barras, porque las otras si llevan dos
        
        if($intPagAct != $this->arrPaginaDatos[$arrInfoSeccion[0]]) {
          $this->oTCPDF->setPage($this->arrPaginaDatos[$arrInfoSeccion[0]] + $this->__intPaginaAct);
          $intPagAct = $this->arrPaginaDatos[$arrInfoSeccion[0]];
          // Se pone el color de fondo
          $this->SetFillColorByArray($this->arrColoresSubTitulos);
        }
        
        // Primero dibujamos el cuadro
        $this->oTCPDF->Rect($this->arrOffsetXDatos[$arrInfoSeccion[0]], $this->intPaddingTop + $this->intBoldHeight, $this->arrAnchoDatos[$arrInfoSeccion[0]], $this->intBoldHeight * 2, "DF");

        // Ahora imprimimos el nombre de la columna
        $this->PonerTexto  ($this->arrOffsetXDatos[$arrInfoSeccion[0]], $this->intPaddingTop + $this->intBoldHeight + ($this->intBoldHeight / 2), $this->arrAnchoDatos[$arrInfoSeccion[0]], $this->intBoldHeight, $this->oReporte->arrInfoReporte[$arrInfoSeccion[0]]["Nombre"], "C");
      } else {
        // Checamos si necesitamos cambiar de pagina
        if($intPagAct != $this->arrPaginaDatos[$arrInfoSeccion[1]]) {
          $this->oTCPDF->setPage($this->arrPaginaDatos[$arrInfoSeccion[1]] + $this->__intPaginaAct);
          $intPagAct = $this->arrPaginaDatos[$arrInfoSeccion[1]];
          // Se pone el color de fondo
          $this->SetFillColorByArray($this->arrColoresSubTitulos);
        }
        
        // Necesitamos poner el renglon de arriba, que necesita el ancho total.
        $fltTotalWidth = 0;
        foreach($arrInfoSeccion as $intIndice => $strNombreCol) {
          if($intIndice == 0) continue; // Linea de titulos

          $fltTotalWidth += $this->arrAnchoDatos[$strNombreCol];
        }
        
        // Ahora ponemos el titulo hasta arriba
        $this->oTCPDF->Rect($this->arrOffsetXDatos[$arrInfoSeccion[1]], $this->intPaddingTop + $this->intBoldHeight, $fltTotalWidth, $this->intBoldHeight);
        $this->PonerTexto  ($this->arrOffsetXDatos[$arrInfoSeccion[1]], $this->intPaddingTop + $this->intBoldHeight, $fltTotalWidth, $this->intBoldHeight, $arrInfoSeccion[0], "C");

        foreach($arrInfoSeccion as $intIndice => $strNombreCol) {
          if($intIndice == 0) continue; // Linea de titulos

          $this->oTCPDF->Rect($this->arrOffsetXDatos[$strNombreCol], $this->intPaddingTop + ($this->intBoldHeight * 2), $this->arrAnchoDatos[$strNombreCol], $this->intBoldHeight);
          $this->PonerTexto  ($this->arrOffsetXDatos[$strNombreCol], $this->intPaddingTop + ($this->intBoldHeight * 2), $this->arrAnchoDatos[$strNombreCol], $this->intBoldHeight, $this->oReporte->arrInfoReporte[$strNombreCol]["Nombre"], "C");
        }
      }
    }
    
    // Colocar la pagina actual como la primer pagina
    $this->oTCPDF->setPage($this->__intPaginaAct + 1);
    
    // Poner letras normales
    $this->oTCPDF->SetFont($this->__strUltimaFuenteUsada, "", $this->__intUltimoTamanioUsado);
  }
  
  function DoRender() {
    $this->__CalcularAnchos();
    
    $intUltimaPagina   = 1;
    $intOffsetY        = $this->intPaddingTop + $this->intBoldHeight + $this->intTotalHeight;
    $intContadorLineas = 0;
    foreach($this->arrDatos as $arrInfoDato) {
      if(($intOffsetY + $this->intNormalHeight - $this->intPaddingTop) > $this->intTotalHeight) {
        $intOffsetY  = $this->intPaddingTop + ($this->intBoldHeight * 3);
        $this->CreateNewPage();
      }
      
      if(@$arrInfoDato["xSubTotx"] == "1") {
        $this->oTCPDF->SetFont($this->__strUltimaFuenteUsada, "B", $this->__intUltimoTamanioUsado);
        $this->SetFillColorByArray($this->arrColoresSubTitulos);
      } else if(@$arrInfoDato["xTotx"] == "1") {
        $this->oTCPDF->SetFont($this->__strUltimaFuenteUsada, "B", $this->__intUltimoTamanioUsado);
        $this->SetFillColorByArray($this->arrColoresTitulos);
      } else {
        $this->oTCPDF->SetFont($this->__strUltimaFuenteUsada, "", $this->__intUltimoTamanioUsado);
        if(++$intContadorLineas % 2) {
          $this->SetFillColorByArray($this->arrColoresAlt0);
        } else {
          $this->SetFillColorByArray($this->arrColoresAlt1);
        }
      }
      
      foreach($this->oReporte->arrInfoReporte as $strNomCol => $arrInfoCol) {
        if($intUltimaPagina != $this->arrPaginaDatos[$strNomCol]) {
          // Se hace cambio de pagina
          $this->oTCPDF->setPage($this->arrPaginaDatos[$strNomCol] + $this->__intPaginaAct);
          $intUltimaPagina = $this->arrPaginaDatos[$strNomCol];
        }
        
        // Obtener el tipo de dato para mostrar nomero a la derecha
        $strTipoDato = substr($this->oReporte->arrInfoReporte[$strNomCol]["Tipo"], 0, 1);
        
        // Verificar si se esta procesando un subtitulo
        if(((@$arrInfoDato["xSubTotx"] == "1") or (@$arrInfoDato["xTotx"] == "1")) and ($strTipoDato == "C") and (isset($this->arrConjTitulos["princ"][$strNomCol]))) {
          // Esta columna lleva el subtitulo
          // Primero calculamos el ancho necesario
          $fltTotalAncho = 0;
          foreach($this->arrConjTitulos["princ"][$strNomCol]["extras"] as $strNomColExtra => $strDescExtra) {
            $fltTotalAncho += $this->arrAnchoDatos[$strNomColExtra];
          }
          $this->PonerTexto  ($this->arrOffsetXDatos[$strNomCol], $intOffsetY, $fltTotalAncho, $this->intNormalHeight, $arrInfoDato[$strNomCol], "");
        } else if(((@$arrInfoDato["xSubTotx"] == "1") or (@$arrInfoDato["xTotx"] == "1")) and ($strTipoDato == "C") and (isset($this->arrConjTitulos["sec"][$strNomCol]))) {
          // Esta columna NO se muestra cuando son subtitulos
        } else {
          // No se esta procesando una de subtitulos, y si es asi esta columna no es de conjunto de titulos
          if(($strTipoDato == "I") or ($strTipoDato == "D") or ($strTipoDato == "F")) {
            switch($strTipoDato) {
              case 'I':
                $this->PonerTexto($this->arrOffsetXDatos[$strNomCol], $intOffsetY, $this->arrAnchoDatos[$strNomCol], $this->intNormalHeight, @intval($arrInfoDato[$strNomCol] - 0), "R");
                break;
              case 'D':
                $this->PonerTexto($this->arrOffsetXDatos[$strNomCol], $intOffsetY, $this->arrAnchoDatos[$strNomCol], $this->intNormalHeight, @number_format($arrInfoDato[$strNomCol] - 0, 2), "R");
                break;
              case 'D':
                $this->PonerTexto($this->arrOffsetXDatos[$strNomCol], $intOffsetY, $this->arrAnchoDatos[$strNomCol], $this->intNormalHeight, @Variables::FormatoCurrency($arrInfoDato[$strNomCol] - 0, 2), "R");
                break;
            }
          } else {
            $this->PonerTexto  ($this->arrOffsetXDatos[$strNomCol], $intOffsetY, $this->arrAnchoDatos[$strNomCol], $this->intNormalHeight, @$arrInfoDato[$strNomCol], "");
          }
        }
        
      }
      $intOffsetY += $this->intNormalHeight;
    }
    
    $this->Guardar();
    die;
    $this->Guardar("uploads/testpdf/t1.pdf", "F");
    die;
    prent_r($this->oTCPDF->getPageDimensions());
    $this->oTCPDF->writeHTML($this->oReporte->DoReporteHTML());
    return $this->Guardar();
//    */
    // Primero necesitamos saber algunos datos del ancho de los mismos para poder
    // ponerlos bien en el reporte sin que salgan cortados
    
  }
  
  /**
   * Funcion que obtiene las columnas conjuntas
   * 
   * Esta funcion llena 2 arreglos:
   * $arrConjTitulos, la cual puede tener columnas conjuntas de subtotal
   * 
   * El formato en ambos casos sera el siguiente:
   * 
   * $arr["princ"][$strNombreColumnaPrinc]["nombre"] = columna principal
   * $arr["princ"][$strNombreColumnaPrinc]["extras"][$strNombreColumna] = Columnas extras, con $strNombreColumna para facil identificacion
   * 
   * $arr["sec"][$strNombreColumna] = columnas extras que participan, para no tomarlas en cuenta cuando se vea algo
   * 
   */
  function __ObtenerColumnasConjuntas() {
    // Primero llenar los de cabeceras
    $intFaltanColumnas   =  0;
    $strColumnaPrincipal = "";
    foreach($this->oReporte->arrInfoReporte as $strNombreCol => $arrInfoCol) {
      if($intFaltanColumnas > 0) {
        // Existen otras columnas que se pondran aqui
        $this->arrConjTitulos["princ"][$strColumnaPrincipal]["extras"][$strNombreCol] = $arrInfoCol["Nombre"];
        $this->arrConjTitulos["sec"  ][$strNombreCol] = $arrInfoCol["Nombre"];
        $intFaltanColumnas--;
      } else {
        if(isset($arrInfoCol["Tipo"])) {
          if(substr($arrInfoCol["Tipo"], 0, 1) == "C") {
            // Es una cabecera, veamos si abarca mas de un renglon
            if(substr($arrInfoCol["Tipo"], 1, 1) - 0) {
              $intFaltanColumnas   = substr($arrInfoCol["Tipo"], 1, 1) - 1;
              $strColumnaPrincipal = $strNombreCol;
            }

            // Ponemos este como principal
            $this->arrConjTitulos["princ"][$strNombreCol]["nombre"] = $arrInfoCol["Nombre"];
            $this->arrConjTitulos["princ"][$strNombreCol]["extras"][$strNombreCol] = $arrInfoCol["Nombre"];
          }
        }
      }
    }
  }
  
  function __CalcularAnchos() {
    $this->oTCPDF->AddPage();
    
    $arrParametrosPagina = $this->oTCPDF->getPageDimensions();
    $this->intTotalWidth       = $arrParametrosPagina["wk"] - $this->intPaddingLeft - $this->intPaddingRight ;
    $this->intTotalHeight      = $arrParametrosPagina["hk"] - $this->intPaddingTop  - $this->intPaddingBottom;
    $this->oTCPDF->deletePage(1);
    
    $this->__ObtenerColumnasConjuntas();
    
    // Calcular el alto de las letras normales
    $this->intNormalHeight = $this->oTCPDF->getStringHeight(0, "AZMjg");
    
    // Los anchos los obtenemos con las letras en negritas para darnos oportunidad de error
    $this->oTCPDF->SetFont($this->__strUltimaFuenteUsada, "B", $this->__intUltimoTamanioUsado);
    
    // Calcular el alto de las letras bold
    $this->intBoldHeight = $this->oTCPDF->getStringHeight(0, "AZMjg");
    
    // Ahora recorremos el arreglo
    // Primero calculamos para las columnas normales (No subtitulos ni nada de eso)
    foreach($this->oReporte->arrInfoReporte as $strNomCol => $arrInfoCol) {
      $arrAnchoDatos[$strNomCol] = $this->oTCPDF->GetStringWidth($arrInfoCol["Nombre"]);
      
      // Ya que estamos encarrerados, checamos el ancho de las columnas con los valores
      foreach($this->arrDatos as $arrInfoDato) {
        if(isset($arrInfoDato["xSubTotx"]) && ($arrInfoDato["xSubTotx"] == "1")) {
          // Es una columna de titulos, por lo que no calculamos por ahora
        } else {
          $fltAnchoAct = $this->oTCPDF->GetStringWidth(@$arrInfoDato[$strNomCol]);
          if($fltAnchoAct > $arrAnchoDatos[$strNomCol]) {
            $arrAnchoDatos[$strNomCol] = $fltAnchoAct;
          }
        }
      }
    }
    
    // Despues calculamos para los subtitulos
    foreach($this->oReporte->arrInfoReporte as $strNomCol => $arrInfoCol) {
      // Podemos checar tambien para las columnas que van agrupadas
      if(is_array($this->oReporte->arrDifHeader)) {
        foreach($this->oReporte->arrDifHeader as $arrInfoDifHeader) {
          if(count($arrInfoDifHeader) > 1) {
            // Esta cabecera es de las que se agrupan.
            // Checamos si el primer campo es el que estamos checando
            if($arrInfoDifHeader[1] == $strNomCol) {
              // SI ES :), hagamos calculos
              $fltAnchoAct = $this->oTCPDF->GetStringWidth($arrInfoDifHeader[0]);
              $fltLenActS  = 0;
              for($i = 1; $i < count($arrInfoDifHeader); $i++) {
                $fltLenActS += $arrAnchoDatos[$arrInfoDifHeader[$i]];
              }
              
              // Vemos si es mayor
              if($fltAnchoAct > $fltLenActS) {
                $strDifNorm = ($fltAnchoAct - $fltLenActS) / (count($arrInfoDifHeader) - 1);
                for($i = 1; $i < count($arrInfoDifHeader); $i++) {
                  $arrAnchoDatos[$arrInfoDifHeader[$i]] += $strDifNorm;
                }
              }
            }
          }
        }
      }
      
      foreach($this->arrDatos as $arrInfoDato) {
        if(isset($arrInfoDato["xSubTotx"]) && ($arrInfoDato["xSubTotx"] == "1")) {
          $fltAnchoAct = $this->oTCPDF->GetStringWidth($arrInfoDato[$strNomCol]);
          // Es una columna de titulos, por lo que se ve si existe alguna agrupacion
          if(isset($this->arrConjTitulos["princ"][$strNomCol])) {
            // Esta es la columna de titulos
            // Primero obtenemos el area de todos para ver si se necesita sumar algo a esa cantidad
            $fltLenActS = 0;
            foreach($this->arrConjTitulos["princ"][$strNomCol]["extras"] as $strNomColExtra => $strDummy) {
              $fltLenActS += $arrAnchoDatos[$strNomColExtra];
            }
            
            // Ahora vemos si esa area es mayor que la que se necesita
            if($fltAnchoAct > $fltLenActS) {
              // Si es mas grande, por lo que la diferencia se la agregareos por igual a todos los campos
              $strDifNorm = ($fltAnchoAct - $fltLenActS) / (count($this->arrConjTitulos["princ"][$strNomCol]["extras"]));
              foreach($this->arrConjTitulos["princ"][$strNomCol]["extras"] as $strNomColExtra => $strDummy) {
                $arrAnchoDatos[$strNomColExtra] += $strDifNorm;
              }
            }
          } else if(isset($this->arrConjTitulos["sec"][$strNomCol])) {
            // Esta columna forma parte de un titulo, pero no se le hace nada especial
            continue;
          } else {
            // Se maneja igual que cualquier otra columna
            if($fltAnchoAct > $arrAnchoDatos[$strNomCol]) {
              $arrAnchoDatos[$strNomCol] = $fltAnchoAct;
            }
          }
        }
      }
    }
    
    // Aumentamos en 1 cada celda para que no se vea tan amontonada
    foreach($arrAnchoDatos as $strNomCol => $fltAnchoAct) {
      $arrAnchoDatos[$strNomCol] = $fltAnchoAct + 4;
    }
    
    // Ahora pasarlos al arreglo del objeto, evitando sobreponer los ya calculados
    foreach($arrAnchoDatos as $strNomCol => $fltAnchoAct) {
      if(isset($this->arrAnchoDatos[$strNomCol])) continue;
      $this->arrAnchoDatos[$strNomCol] = $fltAnchoAct;
    }
    
    // Aqui ya estan calculados los anchos. Ahora calcularemos los offsets y las
    // paginas de cada columna.
    
    // Obtener las columnas el el arreglo especial
    if(is_array($this->oReporte->arrDifHeader) and count($this->oReporte->arrDifHeader)) {
      $arrDifHeader = $this->oReporte->arrDifHeader;
    } else {
      foreach($this->oReporte->arrInfoReporte as $strNombreCol => $arrInfoCol) {
        $arrDifHeader[] = array(0 => $strNombreCol);
      }
    }
    
    
    $intPagAct  = 0;
    $intOffsetX = $this->intPaddingLeft + ($this->intTotalWidth * 2); // Se pone asi para forzar a la creacion de la pagina
    foreach($arrDifHeader as $arrInfoSeccion) {
      if(count($arrInfoSeccion) == 1) {
        // Se verifica si se necesita una pagina nueva
        if(($intOffsetX + $this->arrAnchoDatos[$arrInfoSeccion[0]] - $this->intPaddingLeft) > ($this->intTotalWidth)) {
          // Indicar que los datos van en la siguiente pagina
          $intPagAct++;
          
          // Colocar el offset a lo que en realidad es
          $intOffsetX = $this->intPaddingLeft;
        }
        
        $this->arrPaginaDatos [$arrInfoSeccion[0]] = $intPagAct ;
        $this->arrOffsetXDatos[$arrInfoSeccion[0]] = $intOffsetX;
        
        $intOffsetX += $this->arrAnchoDatos[$arrInfoSeccion[0]];
      } else {
        // Necesitamos poner el renglon de arriba, que necesita el ancho total.
        $fltTotalWidth = 0;
        foreach($arrInfoSeccion as $intIndice => $strNombreCol) {
          if($intIndice == 0) continue; // Linea de titulos

          $fltTotalWidth += $this->arrAnchoDatos[$strNombreCol];
        }
        
        // Si ese ancho sobrepasaria la pagina, ponemos una nueva para ese conjunto de datos
        if(($intOffsetX + $fltTotalWidth - $this->intPaddingLeft) > ($this->intTotalWidth)) {
          // Indicar que los datos van en la siguiente pagina
          $intPagAct++;
          
          // Colocar el offset a lo que en realidad es
          $intOffsetX = $this->intPaddingLeft;
        }
        
        $fltTotalWidth = 0;
        foreach($arrInfoSeccion as $intIndice => $strNombreCol) {
          if($intIndice == 0) continue; // Linea de titulos

          $this->arrPaginaDatos [$strNombreCol] = $intPagAct ;
          $this->arrOffsetXDatos[$strNombreCol] = $intOffsetX + $fltTotalWidth;
          $fltTotalWidth += $this->arrAnchoDatos[$strNombreCol];
        }

        // Por ultimo actualizamos el Width de todo
        $intOffsetX += $fltTotalWidth;
      }
    }
    
    $this->__intTotPags = $intPagAct;
    
    // Si se requiere que se pongan los tamaños del ancho completo de la pagina, se calculan
    if($this->intLlenarWidth) {
      // Primero se obtienen los anchos totales de cada pagina
      for($i = 1; $i <= $this->__intTotPags; $i++) {
        $arrAnchosPagina   [$i] = 0;
        $arrElementosPagina[$i] = 0;
      }
      foreach($this->arrPaginaDatos as $strNomCol => $intPagAct) {
        $arrAnchosPagina   [$intPagAct] += $this->arrAnchoDatos[$strNomCol];
        $arrElementosPagina[$intPagAct]++;
      }
      
      // Ahora se pone el resto de cada pagina en el ancho de cada elemento
      foreach($this->arrPaginaDatos as $strNomCol => $intPagAct) {
        $this->arrAnchoDatos[$strNomCol] += (($this->intTotalWidth - $arrAnchosPagina[$intPagAct]) / $arrElementosPagina[$intPagAct]);
      }
      
      // Como cambiaron losanchos, se necesita recalcular los offsets
      for($i = 1; $i <= $this->__intTotPags; $i++) {
        $arrAnchosPagina[$i] = 0;
      }
      foreach($this->arrPaginaDatos as $strNomCol => $intPagAct) {
        $this->arrOffsetXDatos[$strNomCol] = $this->intPaddingLeft + $arrAnchosPagina[$intPagAct];
        $arrAnchosPagina[$intPagAct] += $this->arrAnchoDatos[$strNomCol];
      }
    }
    
    // Regresar a la letra normal
    $this->oTCPDF->SetFont($this->__strUltimaFuenteUsada, "", $this->__intUltimoTamanioUsado);
  }
}
?>